#js 

#### Объявление массива
```
let arr = new Array();
let arr = [40, 100, 1, 5, 25, 10];
```
#### Проверка объекта на массив
```
Массив фактически является объектом и для проверки, является ли объект массивом используется метод isArray().
console.log('Массив это массив = ' + Array.isArray([])); // true
console.log('Объект это массив = ' + Array.isArray({})); // false
console.log('Тип данных массива = ' + typeof []) // object
console.log('Тип данных объекта = ' + typeof {}); // object
```
#### Добавление и удаление элементов
```
- push добавляет элемент в конец
- pop удаляет последний элемент
- shift удаляет из массива первый элемент и возвращает его
- unshift добавляет элемент в начало массива
```
#### Перебор элементов
```
let arr = ["Яблоко", "Апельсин", "Груша"]; 
for (let i = 0; i < arr.length; i++) {
	alert(arr[i]);
}
for (let elem of arr) {
	alert(elem);
}
for (let key in arr) { // Нерекомендованный способ перебора
	alert(arr[key]);
}
arr.forEach(
	(item, index, array) => {
			alert(`У ${item} индекс ${index} в ${array}`);
		}
	);
```
#### Перебор элементов с помощью reduce/reduceRight
```
Происходит перебор элементов с передачей в качестве первого агрумента результата работы предыдущего вызова. reduceRight работает в противоположеном порядке с конца массива.
let arr = [1, 2, 3, 4, 5];
let result = arr.reduce(sumElement);
function sumElement(sum, current) {
	return sum + current;
}
console.log(result); // 15
```
#### Получение последнего элемента
```
let arr = ["Apple", "Orange", "Plum"];
alert(arr[arr.length-1]); // Plum
alert(arr.at(-1));        // Plum
```
#### Удаление элементов массива
```
let arr = ["Я", "изучаю", "JavaScript", "сейчас"];
let removed = arr.splice(1, 2); // начиная с индекса 1, удалить 2 элемента
alert(arr); // осталось ["Я", "JavaScript", "сейчас"]
alert(removed); // "изучаю", "JavaScript" <-- массив из удалённых элементов
```
#### Замена элементов
```
let arr = ["Я", "изучаю", "JavaScript", "прямо", "сейчас"]; // удалить 3 первых элемента и заменить их другими
arr.splice(0, 3, "Давай", "танцевать");
alert(arr) // теперь ["Давай", "танцевать", "прямо", "сейчас"]
```
#### Вставка элементов
```
let arr = ["Я", "изучаю", "JavaScript"];
// с индекса 2 удалить 0 элементов и вставить "сложный", "язык"
arr.splice(2, 0, "сложный", "язык");
alert(arr); // "Я", "изучаю", "сложный", "язык", "JavaScript"
```
#### Отрицательные индексы производят отсчет с конца массива
```
let arr = [1, 2, 5];
// начиная с индекса -1 (перед последним элементом)
// удалить 0 элементов, затем вставить числа 3 и 4
arr.splice(-1, 0, 3, 4);
alert(arr); // 1,2,3,4,5
```
#### Копирование части массива в новый массив
```
let arr = ["t", "e", "s", "t"];
alert( arr.slice(1, 3) ); // e,s (копирует с 1 до 3)
alert(arr.slice(-2)); // s,t (копирует с -2 до конца)
```
#### Копирование указанных элементов в новый массив
```
let arr = [1, 2];
// создать массив из: arr и [3, 4]
alert( arr.concat([3, 4]) ); // 1,2,3,4
// создать массив из: arr и [3,4] и [5,6]
alert( arr.concat([3, 4], [5, 6]) ); // 1,2,3,4,5,6
// создать массив из: arr и [3,4], потом добавить значения 5 и 6
alert( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6

Объекты копируются как [object Object], если не содержат свойства Symbol.isConcatSpreadable.
```
#### Поиск элемента в массиве
```
- arr.indexOf(item, from) ищет 'item' начиная с индекса 'from' и возвращает номер индекса, на котором был найден искомый элемент, в противном случае '-1' (lastIndexOf(): поиск справа налево).
- 'arr.includes(item, from)' ищет 'item' начиная с индекса 'from' и возвращает 'true', если поиск успешен.
let arr = ["t", "e", "s", "t"];
alert(arr.indexOf("s")); // 2
alert(arr.includes("e")); // true

// Метод includes корректно обрабатывает NaN
const arr = [NaN];
alert(arr.indexOf(NaN));  // -1 (неверно, должен быть 0)
alert(arr.includes(NaN)); // true (верно)

let elem = 'example';
let arr = new Array();
if (!Object.values(arr).includes(elem)) {
	console.log(elem);
}
```
#### Поиск в массиве объектов: find и findIndex/findLastIndex
```
let users = [
	{id: 1, name: "Вася"},
	{id: 2, name: "Петя"},
	{id: 3, name: "Маша"}
];
// find - поиск первого объекта в массиве по условию
let found = users.find(function (element) {
	return element.id > 2;
});
console.log(found); // { id: 3, name: 'Маша' }

// findIndex - поиск первого номера объекта в массиве по условию с начала массива
let found = users.findIndex(function (element) {
	console.log(element.id);
	return element.id >= 2;
});
console.log(found); // 1

// findLastIndex - поиск первого номера объекта в массиве по условию с конца массива
let found = users.findLastIndex(function (element) {
	console.log(element.id);
	return element.id >= 2;
});
console.log(found); // 2
```
#### Фильтрация массива: filter
```
let users = [
	{id: 1, name: "Вася"},
	{id: 2, name: "Петя"},
	{id: 3, name: "Маша"}
];
const result = users.filter(check);
function check(entry) {
	return entry.id >= 2;
}
console.log(result) // [ { id: 2, name: 'Петя' }, { id: 3, name: 'Маша' } ]

let arr = new Array();
arr.push(1);
arr.push(4);
arr.push(10);
arr.push(25);
arr.filter(
	function(o) {
	if (o > 5) {
		return true;
	}
});
```
#### Выполнение функции с каждым элементом массива: map
```
let users = [
	{id: 1, name: "Анатолий"},
	{id: 3, name: "Маша"},
	{id: 2, name: "Евпатий"}
];
const result = users.map(check);
function check(age) {
	return age.name.length;
}
console.log(result) // [ 8, 7, 4 ]
```
#### Сортировка, общая и по условию: sort
```
По умолчанию элементы сортируются кк строки, поэтому для чисел необходимо прописывать условие.
// Общая сортировка по ключам одномерного массива
let arr = [ 1, 2, 15 ];
arr.sort();
console.log(arr) // [ 1, 15, 2 ]

// Общая сортировка по ключам многомерного массива
let users = [
	{id: 9, name: "Анатолий"},
	{id: 3, name: "Маша"},
	{id: 2, name: "Евпатий"}
];
const result = users.sort(compare);
function compare(a, b) {
	if (a.id > b.id) return 1; // если первое значение больше второго
	if (a.id == b.id) return 0; // если равны
	if (a.id < b.id) return -1; // если первое значение меньше второго
}
console.log(result)

// Для сортировки строк использовать функцию localeCompare().
let countries = ['Österreich', 'Andorra', 'Vietnam'];
function compare(a, b) {
	return a.localeCompare(b);
}
console.log(countries.sort(compare)); // [ 'Andorra', 'Österreich', 'Vietnam' ]
```
#### Изменить порядок элементов на обратный: reverse
```
let arr = [1, 2, 3, 4, 5];
arr.reverse(); // Метод так же возвращцет ссылку на измененный массив
console.log(arr); // [ 5, 4, 3, 2, 1 ]
```
#### Разделить строку на массив элементов: split
```
let names = 'Вася, Петя, Маша';
let arr = names.split(', ');
console.log(arr) // [ 'Вася', 'Петя', 'Маша' ]

// Разделить строку под буквам
let str = "тест";
console.log( str.split('') ); // [ 'т', 'е', 'с', 'т' ]
```
#### Объединить строку из массива элементов: join
```
let arr = ['Вася', 'Петя', 'Маша'];
let str = arr.join(';'); ;
console.log(str); // Вася;Петя;Маша
```